home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / controls / scrollClasses / ScrollBar.as next >
Encoding:
Text File  |  2010-05-14  |  21.5 KB  |  596 lines
  1. package mx.controls.scrollClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.MouseEvent;
  6.    import flash.events.TimerEvent;
  7.    import flash.geom.Point;
  8.    import flash.ui.Keyboard;
  9.    import flash.utils.Timer;
  10.    import mx.controls.Button;
  11.    import mx.core.UIComponent;
  12.    import mx.core.mx_internal;
  13.    import mx.events.FlexEvent;
  14.    import mx.events.ScrollEvent;
  15.    import mx.events.ScrollEventDetail;
  16.    import mx.styles.ISimpleStyleClient;
  17.    
  18.    use namespace mx_internal;
  19.    
  20.    public class ScrollBar extends UIComponent
  21.    {
  22.       mx_internal static const VERSION:String = "2.0.1.0";
  23.       
  24.       public static const THICKNESS:Number = 16;
  25.       
  26.       mx_internal var isScrolling:Boolean;
  27.       
  28.       mx_internal var oldPosition:Number;
  29.       
  30.       mx_internal var downArrow:Button;
  31.       
  32.       private var _pageSize:Number = 0;
  33.       
  34.       mx_internal var _minHeight:Number = 32;
  35.       
  36.       private var trackScrolling:Boolean = false;
  37.       
  38.       private var trackScrollRepeatDirection:int;
  39.       
  40.       private var _scrollPosition:Number = 0;
  41.       
  42.       private var _lineScrollSize:Number = 1;
  43.       
  44.       private var _direction:String = "vertical";
  45.       
  46.       mx_internal var upArrow:Button;
  47.       
  48.       private var trackScrollTimer:Timer;
  49.       
  50.       mx_internal var scrollTrack:DisplayObject;
  51.       
  52.       private var _pageScrollSize:Number = 0;
  53.       
  54.       private var _maxScrollPosition:Number = 0;
  55.       
  56.       mx_internal var scrollThumb:ScrollThumb;
  57.       
  58.       private var _minScrollPosition:Number = 0;
  59.       
  60.       private var trackPosition:Number;
  61.       
  62.       mx_internal var _minWidth:Number = 16;
  63.       
  64.       public function ScrollBar()
  65.       {
  66.          mx_internal::_minWidth = 16;
  67.          mx_internal::_minHeight = 32;
  68.          trackScrolling = false;
  69.          _direction = ScrollBarDirection.VERTICAL;
  70.          _lineScrollSize = 1;
  71.          _maxScrollPosition = 0;
  72.          _minScrollPosition = 0;
  73.          _pageSize = 0;
  74.          _pageScrollSize = 0;
  75.          _scrollPosition = 0;
  76.          super();
  77.       }
  78.       
  79.       private function downArrow_buttonDownHandler(param1:FlexEvent) : void
  80.       {
  81.          if(isNaN(mx_internal::oldPosition))
  82.          {
  83.             mx_internal::oldPosition = scrollPosition;
  84.          }
  85.          mx_internal::lineScroll(1);
  86.       }
  87.       
  88.       public function set minScrollPosition(param1:Number) : void
  89.       {
  90.          _minScrollPosition = param1;
  91.       }
  92.       
  93.       mx_internal function get virtualHeight() : Number
  94.       {
  95.          return unscaledHeight;
  96.       }
  97.       
  98.       mx_internal function get lineMinusDetail() : String
  99.       {
  100.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_LEFT;
  101.       }
  102.       
  103.       public function setScrollProperties(param1:Number, param2:Number, param3:Number, param4:Number = 0) : void
  104.       {
  105.          var _loc5_:Number = NaN;
  106.          this.pageSize = param1;
  107.          _pageScrollSize = param4 > 0 ? param4 : param1;
  108.          this.minScrollPosition = Math.max(param2,0);
  109.          this.maxScrollPosition = Math.max(param3,0);
  110.          _scrollPosition = Math.max(this.minScrollPosition,_scrollPosition);
  111.          _scrollPosition = Math.min(this.maxScrollPosition,_scrollPosition);
  112.          if(this.maxScrollPosition - this.minScrollPosition > 0 && enabled)
  113.          {
  114.             mx_internal::upArrow.enabled = true;
  115.             mx_internal::downArrow.enabled = true;
  116.             addEventListener(MouseEvent.MOUSE_DOWN,scrollTrack_mouseDownHandler);
  117.             addEventListener(MouseEvent.MOUSE_OVER,scrollTrack_mouseOverHandler);
  118.             addEventListener(MouseEvent.MOUSE_OUT,scrollTrack_mouseOutHandler);
  119.             if(!mx_internal::scrollThumb)
  120.             {
  121.                mx_internal::scrollThumb = new ScrollThumb();
  122.                mx_internal::scrollThumb.focusEnabled = false;
  123.                addChildAt(mx_internal::scrollThumb,getChildIndex(mx_internal::downArrow));
  124.                mx_internal::scrollThumb.styleName = this;
  125.                mx_internal::scrollThumb.mx_internal::upSkinName = "thumbUpSkin";
  126.                mx_internal::scrollThumb.mx_internal::overSkinName = "thumbOverSkin";
  127.                mx_internal::scrollThumb.mx_internal::downSkinName = "thumbDownSkin";
  128.                mx_internal::scrollThumb.mx_internal::iconName = "thumbIcon";
  129.             }
  130.             _loc5_ = trackHeight < 0 ? 0 : Math.round(param1 / (this.maxScrollPosition - this.minScrollPosition + param1) * trackHeight);
  131.             if(_loc5_ < mx_internal::scrollThumb.minHeight)
  132.             {
  133.                if(trackHeight < mx_internal::scrollThumb.minHeight)
  134.                {
  135.                   mx_internal::scrollThumb.visible = false;
  136.                }
  137.                else
  138.                {
  139.                   _loc5_ = mx_internal::scrollThumb.minHeight;
  140.                   mx_internal::scrollThumb.visible = true;
  141.                   mx_internal::scrollThumb.setActualSize(mx_internal::_minWidth,mx_internal::scrollThumb.minHeight);
  142.                }
  143.             }
  144.             else
  145.             {
  146.                mx_internal::scrollThumb.visible = true;
  147.                mx_internal::scrollThumb.setActualSize(mx_internal::_minWidth,_loc5_);
  148.             }
  149.             mx_internal::scrollThumb.mx_internal::setRange(mx_internal::upArrow.getExplicitOrMeasuredHeight() + 0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight() - mx_internal::scrollThumb.height,this.minScrollPosition,this.maxScrollPosition);
  150.             scrollPosition = Math.max(Math.min(scrollPosition,this.maxScrollPosition),this.minScrollPosition);
  151.          }
  152.          else
  153.          {
  154.             mx_internal::upArrow.enabled = false;
  155.             mx_internal::downArrow.enabled = false;
  156.             if(mx_internal::scrollThumb)
  157.             {
  158.                mx_internal::scrollThumb.visible = false;
  159.             }
  160.          }
  161.       }
  162.       
  163.       public function get pageScrollSize() : Number
  164.       {
  165.          return _pageScrollSize;
  166.       }
  167.       
  168.       private function get trackY() : Number
  169.       {
  170.          return mx_internal::upArrow.getExplicitOrMeasuredHeight();
  171.       }
  172.       
  173.       public function set pageScrollSize(param1:Number) : void
  174.       {
  175.          _pageScrollSize = param1;
  176.       }
  177.       
  178.       mx_internal function isScrollBarKey(param1:uint) : Boolean
  179.       {
  180.          var _loc2_:Number = NaN;
  181.          if(param1 == Keyboard.HOME)
  182.          {
  183.             if(scrollPosition != 0)
  184.             {
  185.                _loc2_ = scrollPosition;
  186.                scrollPosition = 0;
  187.                mx_internal::dispatchScrollEvent(_loc2_,minDetail);
  188.             }
  189.             return true;
  190.          }
  191.          if(param1 == Keyboard.END)
  192.          {
  193.             if(scrollPosition < maxScrollPosition)
  194.             {
  195.                _loc2_ = scrollPosition;
  196.                scrollPosition = maxScrollPosition;
  197.                mx_internal::dispatchScrollEvent(_loc2_,maxDetail);
  198.             }
  199.             return true;
  200.          }
  201.          return false;
  202.       }
  203.       
  204.       private function trackScrollTimerHandler(param1:Event) : void
  205.       {
  206.          if(trackScrollRepeatDirection == 1)
  207.          {
  208.             if(mx_internal::scrollThumb.y + mx_internal::scrollThumb.height > trackPosition)
  209.             {
  210.                return;
  211.             }
  212.          }
  213.          if(trackScrollRepeatDirection == -1)
  214.          {
  215.             if(mx_internal::scrollThumb.y < trackPosition)
  216.             {
  217.                return;
  218.             }
  219.          }
  220.          mx_internal::pageScroll(trackScrollRepeatDirection);
  221.          if(Boolean(trackScrollTimer) && trackScrollTimer.repeatCount == 1)
  222.          {
  223.             trackScrollTimer.delay = getStyle("repeatInterval");
  224.             trackScrollTimer.repeatCount = 0;
  225.          }
  226.       }
  227.       
  228.       private function scrollTrack_mouseUpHandler(param1:MouseEvent) : void
  229.       {
  230.          scrollTrack_mouseLeaveHandler(param1);
  231.       }
  232.       
  233.       private function get minDetail() : String
  234.       {
  235.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_TOP : ScrollEventDetail.AT_LEFT;
  236.       }
  237.       
  238.       override protected function measure() : void
  239.       {
  240.          super.measure();
  241.          mx_internal::upArrow.validateSize();
  242.          mx_internal::downArrow.validateSize();
  243.          mx_internal::_minWidth = mx_internal::upArrow.getExplicitOrMeasuredWidth();
  244.          mx_internal::_minHeight = mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight();
  245.       }
  246.       
  247.       public function get maxScrollPosition() : Number
  248.       {
  249.          return _maxScrollPosition;
  250.       }
  251.       
  252.       mx_internal function get linePlusDetail() : String
  253.       {
  254.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_DOWN : ScrollEventDetail.LINE_RIGHT;
  255.       }
  256.       
  257.       private function stage_scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  258.       {
  259.          if(param1.target != stage)
  260.          {
  261.             return;
  262.          }
  263.          scrollTrack_mouseMoveHandler(param1);
  264.       }
  265.       
  266.       private function upArrow_buttonDownHandler(param1:FlexEvent) : void
  267.       {
  268.          if(isNaN(mx_internal::oldPosition))
  269.          {
  270.             mx_internal::oldPosition = scrollPosition;
  271.          }
  272.          mx_internal::lineScroll(-1);
  273.       }
  274.       
  275.       private function scrollTrack_mouseOverHandler(param1:MouseEvent) : void
  276.       {
  277.          if(param1.target != this)
  278.          {
  279.             return;
  280.          }
  281.          if(trackScrolling)
  282.          {
  283.             trackScrollTimer.start();
  284.          }
  285.       }
  286.       
  287.       private function scrollTrack_mouseDownHandler(param1:MouseEvent) : void
  288.       {
  289.          if(param1.target != this)
  290.          {
  291.             return;
  292.          }
  293.          trackScrolling = true;
  294.          systemManager.addEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  295.          systemManager.addEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  296.          systemManager.stage.addEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  297.          systemManager.stage.addEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  298.          trackPosition = param1.localY;
  299.          if(isNaN(mx_internal::oldPosition))
  300.          {
  301.             mx_internal::oldPosition = scrollPosition;
  302.          }
  303.          trackScrollRepeatDirection = mx_internal::scrollThumb.y + mx_internal::scrollThumb.height < param1.localY ? 1 : (mx_internal::scrollThumb.y > param1.localY ? -1 : 0);
  304.          mx_internal::pageScroll(trackScrollRepeatDirection);
  305.          if(!trackScrollTimer)
  306.          {
  307.             trackScrollTimer = new Timer(getStyle("repeatDelay"),1);
  308.             trackScrollTimer.addEventListener(TimerEvent.TIMER,trackScrollTimerHandler);
  309.          }
  310.          trackScrollTimer.start();
  311.       }
  312.       
  313.       public function get minScrollPosition() : Number
  314.       {
  315.          return _minScrollPosition;
  316.       }
  317.       
  318.       override public function set doubleClickEnabled(param1:Boolean) : void
  319.       {
  320.       }
  321.       
  322.       public function set scrollPosition(param1:Number) : void
  323.       {
  324.          var _loc2_:Number = NaN;
  325.          var _loc3_:Number = NaN;
  326.          _scrollPosition = param1;
  327.          if(mx_internal::scrollThumb)
  328.          {
  329.             if(!cacheAsBitmap)
  330.             {
  331.                cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = true;
  332.             }
  333.             if(!mx_internal::isScrolling)
  334.             {
  335.                param1 = Math.min(param1,maxScrollPosition);
  336.                param1 = Math.max(param1,minScrollPosition);
  337.                _loc2_ = maxScrollPosition - minScrollPosition;
  338.                _loc3_ = _loc2_ == 0 || isNaN(_loc2_) ? 0 : (param1 - minScrollPosition) * (trackHeight - mx_internal::scrollThumb.height) / _loc2_ + trackY;
  339.                mx_internal::scrollThumb.move(0,Math.round(_loc3_));
  340.             }
  341.          }
  342.       }
  343.       
  344.       mx_internal function pageScroll(param1:int) : void
  345.       {
  346.          var _loc2_:Number = NaN;
  347.          var _loc3_:Number = NaN;
  348.          var _loc4_:Number = NaN;
  349.          var _loc5_:String = null;
  350.          _loc2_ = _pageScrollSize != 0 ? _pageScrollSize : pageSize;
  351.          _loc3_ = _scrollPosition + param1 * _loc2_;
  352.          if(_loc3_ > maxScrollPosition)
  353.          {
  354.             _loc3_ = maxScrollPosition;
  355.          }
  356.          else if(_loc3_ < minScrollPosition)
  357.          {
  358.             _loc3_ = minScrollPosition;
  359.          }
  360.          if(_loc3_ != scrollPosition)
  361.          {
  362.             _loc4_ = scrollPosition;
  363.             scrollPosition = _loc3_;
  364.             _loc5_ = param1 < 0 ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  365.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  366.          }
  367.       }
  368.       
  369.       private function scrollTrack_mouseLeaveHandler(param1:Event) : void
  370.       {
  371.          var _loc2_:String = null;
  372.          trackScrolling = false;
  373.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  374.          systemManager.removeEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  375.          systemManager.stage.removeEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  376.          systemManager.stage.removeEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  377.          if(trackScrollTimer)
  378.          {
  379.             trackScrollTimer.reset();
  380.          }
  381.          if(param1.target != this)
  382.          {
  383.             return;
  384.          }
  385.          _loc2_ = mx_internal::oldPosition > scrollPosition ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  386.          mx_internal::dispatchScrollEvent(mx_internal::oldPosition,_loc2_);
  387.          mx_internal::oldPosition = NaN;
  388.       }
  389.       
  390.       private function get trackHeight() : Number
  391.       {
  392.          return mx_internal::virtualHeight - (mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight());
  393.       }
  394.       
  395.       public function set pageSize(param1:Number) : void
  396.       {
  397.          _pageSize = param1;
  398.       }
  399.       
  400.       mx_internal function get pagePlusDetail() : String
  401.       {
  402.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_DOWN : ScrollEventDetail.PAGE_RIGHT;
  403.       }
  404.       
  405.       override public function set enabled(param1:Boolean) : void
  406.       {
  407.          super.enabled = param1;
  408.          invalidateDisplayList();
  409.       }
  410.       
  411.       mx_internal function get pageMinusDetail() : String
  412.       {
  413.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_UP : ScrollEventDetail.PAGE_LEFT;
  414.       }
  415.       
  416.       private function get maxDetail() : String
  417.       {
  418.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_BOTTOM : ScrollEventDetail.AT_RIGHT;
  419.       }
  420.       
  421.       private function scrollTrack_mouseOutHandler(param1:MouseEvent) : void
  422.       {
  423.          if(trackScrolling)
  424.          {
  425.             trackScrollTimer.stop();
  426.          }
  427.       }
  428.       
  429.       mx_internal function dispatchScrollEvent(param1:Number, param2:String) : void
  430.       {
  431.          var _loc3_:ScrollEvent = null;
  432.          _loc3_ = new ScrollEvent(ScrollEvent.SCROLL);
  433.          _loc3_.detail = param2;
  434.          _loc3_.position = scrollPosition;
  435.          _loc3_.delta = scrollPosition - param1;
  436.          _loc3_.direction = direction;
  437.          dispatchEvent(_loc3_);
  438.       }
  439.       
  440.       public function set lineScrollSize(param1:Number) : void
  441.       {
  442.          _lineScrollSize = param1;
  443.       }
  444.       
  445.       public function set direction(param1:String) : void
  446.       {
  447.          _direction = param1;
  448.          invalidateSize();
  449.          invalidateDisplayList();
  450.          dispatchEvent(new Event("directionChanged"));
  451.       }
  452.       
  453.       public function get scrollPosition() : Number
  454.       {
  455.          return _scrollPosition;
  456.       }
  457.       
  458.       override protected function createChildren() : void
  459.       {
  460.          var _loc1_:Class = null;
  461.          super.createChildren();
  462.          if(!mx_internal::scrollTrack)
  463.          {
  464.             _loc1_ = getStyle("trackSkin");
  465.             mx_internal::scrollTrack = new _loc1_();
  466.             if(mx_internal::scrollTrack is ISimpleStyleClient)
  467.             {
  468.                ISimpleStyleClient(mx_internal::scrollTrack).styleName = this;
  469.             }
  470.             addChild(mx_internal::scrollTrack);
  471.          }
  472.          if(!mx_internal::upArrow)
  473.          {
  474.             mx_internal::upArrow = new Button();
  475.             mx_internal::upArrow.enabled = false;
  476.             mx_internal::upArrow.autoRepeat = true;
  477.             mx_internal::upArrow.focusEnabled = false;
  478.             mx_internal::upArrow.mx_internal::upSkinName = "upArrowUpSkin";
  479.             mx_internal::upArrow.mx_internal::overSkinName = "upArrowOverSkin";
  480.             mx_internal::upArrow.mx_internal::downSkinName = "upArrowDownSkin";
  481.             mx_internal::upArrow.mx_internal::disabledSkinName = "upArrowDisabledSkin";
  482.             mx_internal::upArrow.mx_internal::upIconName = "";
  483.             mx_internal::upArrow.mx_internal::overIconName = "";
  484.             mx_internal::upArrow.mx_internal::downIconName = "";
  485.             mx_internal::upArrow.mx_internal::disabledIconName = "";
  486.             addChild(mx_internal::upArrow);
  487.             mx_internal::upArrow.styleName = this;
  488.             mx_internal::upArrow.validateProperties();
  489.             mx_internal::upArrow.addEventListener(FlexEvent.BUTTON_DOWN,upArrow_buttonDownHandler);
  490.          }
  491.          if(!mx_internal::downArrow)
  492.          {
  493.             mx_internal::downArrow = new Button();
  494.             mx_internal::downArrow.enabled = false;
  495.             mx_internal::downArrow.autoRepeat = true;
  496.             mx_internal::downArrow.focusEnabled = false;
  497.             mx_internal::downArrow.mx_internal::upSkinName = "downArrowUpSkin";
  498.             mx_internal::downArrow.mx_internal::overSkinName = "downArrowOverSkin";
  499.             mx_internal::downArrow.mx_internal::downSkinName = "downArrowDownSkin";
  500.             mx_internal::downArrow.mx_internal::disabledSkinName = "downArrowDisabledSkin";
  501.             mx_internal::downArrow.mx_internal::upIconName = "";
  502.             mx_internal::downArrow.mx_internal::overIconName = "";
  503.             mx_internal::downArrow.mx_internal::downIconName = "";
  504.             mx_internal::downArrow.mx_internal::disabledIconName = "";
  505.             addChild(mx_internal::downArrow);
  506.             mx_internal::downArrow.styleName = this;
  507.             mx_internal::downArrow.validateProperties();
  508.             mx_internal::downArrow.addEventListener(FlexEvent.BUTTON_DOWN,downArrow_buttonDownHandler);
  509.          }
  510.       }
  511.       
  512.       public function set maxScrollPosition(param1:Number) : void
  513.       {
  514.          _maxScrollPosition = param1;
  515.       }
  516.       
  517.       public function get pageSize() : Number
  518.       {
  519.          return _pageSize;
  520.       }
  521.       
  522.       [Bindable("directionChanged")]
  523.       public function get direction() : String
  524.       {
  525.          return _direction;
  526.       }
  527.       
  528.       public function get lineScrollSize() : Number
  529.       {
  530.          return _lineScrollSize;
  531.       }
  532.       
  533.       mx_internal function lineScroll(param1:int) : void
  534.       {
  535.          var _loc2_:Number = NaN;
  536.          var _loc3_:Number = NaN;
  537.          var _loc4_:Number = NaN;
  538.          var _loc5_:String = null;
  539.          _loc2_ = _lineScrollSize;
  540.          _loc3_ = _scrollPosition + param1 * _loc2_;
  541.          if(_loc3_ > maxScrollPosition)
  542.          {
  543.             _loc3_ = maxScrollPosition;
  544.          }
  545.          else if(_loc3_ < minScrollPosition)
  546.          {
  547.             _loc3_ = minScrollPosition;
  548.          }
  549.          if(_loc3_ != scrollPosition)
  550.          {
  551.             _loc4_ = scrollPosition;
  552.             scrollPosition = _loc3_;
  553.             _loc5_ = param1 < 0 ? mx_internal::lineMinusDetail : mx_internal::linePlusDetail;
  554.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  555.          }
  556.       }
  557.       
  558.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  559.       {
  560.          if(mx_internal::$height == 1)
  561.          {
  562.             return;
  563.          }
  564.          if(!mx_internal::upArrow)
  565.          {
  566.             return;
  567.          }
  568.          super.updateDisplayList(param1,param2);
  569.          if(cacheAsBitmap)
  570.          {
  571.             cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = false;
  572.          }
  573.          mx_internal::upArrow.move(0,0);
  574.          mx_internal::upArrow.setActualSize(mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredHeight());
  575.          mx_internal::scrollTrack.y = 0;
  576.          mx_internal::scrollTrack.height = mx_internal::virtualHeight;
  577.          mx_internal::downArrow.move(0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  578.          mx_internal::downArrow.setActualSize(mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredHeight());
  579.          setScrollProperties(pageSize,minScrollPosition,maxScrollPosition,_pageScrollSize);
  580.          scrollPosition = _scrollPosition;
  581.       }
  582.       
  583.       private function scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  584.       {
  585.          var _loc2_:Point = null;
  586.          if(trackScrolling)
  587.          {
  588.             _loc2_ = new Point(param1.stageX,param1.stageY);
  589.             _loc2_ = globalToLocal(_loc2_);
  590.             trackPosition = _loc2_.y;
  591.          }
  592.       }
  593.    }
  594. }
  595.  
  596.